home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / program / 152 / doodle2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-06-21  |  59.0 KB  |  1,742 lines
  1. /************************************************************************/
  2. /*      File:   doodle.c                                                */
  3. /************************************************************************/
  4. /* ATARI ADAPTATION IN COLOR BY HARRY KOONS    VERSION 1.1B    7/11/85  */
  5. /*      includes         ****************************************       */
  6. #include <osbind.h>                             /* gemdos bindings      */
  7. #include <obdefs.h>                             /* object definitions   */
  8. #include <gemdefs.h>                            /* misc gem definitions */
  9. #include <vdibind.h>                            /* vdi binding structs  */
  10. #include <vdibind.h>                            /* vdi binding structs  */
  11. #include <portab.h>                             /* portable coding conv */
  12. /* #include "machine.h" i.e. pick what works!      machine dependent    */
  13. #include <define.h>                             /* misc. definitions    */
  14. #include <taddr.h>                              /* tree address macros  */
  15. #include <doodle2.h>               /* doodle2-RCS-application resource  */
  16. /*      defines      ****************************************           */
  17. #define DESK            0
  18.  
  19. #define END_UPDATE      0
  20. #define BEG_UPDATE      1
  21.  
  22. #define SHADE0          0
  23. #define SHADE1          1
  24. #define SHADE2          2
  25. #define SHADE3          3
  26. #define SHADE4          4
  27. #define SHADE5          5
  28. #define SHADE6          6
  29. #define SHADE7          7
  30. #define SHADE8          8
  31. #define SHADE9          9
  32. #define SHADE10         10
  33. #define SHADE11         11
  34. #define SHADE12         12
  35. #define SHADE13         13
  36. #define SHADE14         14
  37. #define SHADE15         15
  38.  
  39.  
  40.  
  41. #define PEN_FINE        1
  42. #define PEN_MEDIUM      5
  43. #define PEN_BROAD       9
  44.  
  45.  
  46. #define WA_UPPAGE       0               /* arrow message        */
  47. #define WA_DNPAGE       1
  48. #define WA_UPLINE       2
  49. #define WA_DNLINE       3
  50. #define WA_LFPAGE       4
  51. #define WA_RTPAGE       5
  52. #define WA_LFLINE       6
  53. #define WA_RTLINE       7
  54.  
  55.  
  56. /*      Macros    **************************************              */
  57. #define LLGET(x) (*((LONG*)(x)))
  58. #define LLSET(x,y) (*((LONG*)(x))=y)
  59. #define LWGET(x) ((WORD)*((WORD*)(x)))
  60. #define LWSET(x,y) (*((WORD*)(x))=y)
  61. #define YSCALE(x) UMD(x, scrn_xsize, scrn_ysize)
  62. #define TE_TXTLEN(x) (x + 24)
  63. #define ADDR /**/
  64. #define GLOBAL /**/
  65. /****                       Data Structures                          ****/
  66. /*      Extrnl Data Structures  *****************************************/
  67. UWORD   dos_err;        /* no longer external  */
  68. /*      Global Data Structures  *****************************************/
  69.  
  70. GLOBAL WORD     contrl[11];             /* control inputs               */
  71. GLOBAL WORD     intin[80];              /* max string length            */
  72. GLOBAL WORD     ptsin[256];             /* polygon fill points          */
  73. GLOBAL WORD     intout[45];             /* open workstation output      */
  74. GLOBAL WORD     ptsout[12];
  75. /*      Local Data Structures   */
  76. WORD    gl_wchar;                       /* character width              */
  77. WORD    gl_hchar;                       /* character height             */
  78. WORD    gl_wbox;                        /* box (cell) width             */
  79. WORD    gl_hbox;                        /* box (cell) height            */
  80. WORD    gl_hspace;                      /* height of space between lines*/
  81. WORD    gem_handle;                     /* GEM vdi handle               */
  82. WORD    vdi_handle;                     /* doodle vdi handle            */
  83. WORD    work_out[57];                   /* open virt workstation values */
  84. GRECT   scrn_area;                      /* whole scrn area              */
  85. GRECT   work_area;                      /* drawing area of main window  */
  86. GRECT   undo_area;                      /* area equal to work_area      */
  87. GRECT   save_area;                      /* save area for full/unfulling */
  88. WORD    gl_rmsg[8];                     /* message buffer               */
  89. LONG    ad_rmsg;                        /* LONG pointer to message bfr  */
  90. LONG    gl_menu;                        /* menu tree address            */
  91. WORD    gl_apid;                        /* application ID               */
  92. WORD    gl_xfull;                       /* full window 'x'              */
  93. WORD    gl_yfull;                       /* full window 'y'              */
  94. WORD    gl_wfull;                       /* full window 'w'              */
  95. WORD    gl_hfull;                       /* full window 'h'              */
  96. WORD    scrn_width;                     /* scrn width in pixels */
  97. WORD    scrn_height;                    /* scrn height in pixels        */
  98. WORD    scrn_planes;                    /* number of color planes       */
  99. WORD    scrn_xsize;                     /* width of one pixel           */
  100. WORD    scrn_ysize;                     /* height of one pixel          */
  101. UWORD   m_out = FALSE;                  /* mouse in/out of window flag  */
  102. WORD    ev_which;                       /* event multi return state(s)  */
  103. UWORD   mousex, mousey;                 /* mouse x,y position           */
  104. UWORD   bstate, bclicks;                /* button state, & # of clicks  */
  105. UWORD   kstate, kreturn;                /* key state and keyboard char  */
  106. MFDB    undo_mfdb;                      /* undo buffer mmry frm def blk */
  107. MFDB    scrn_mfdb;                      /* scrn memory form defn blk    */
  108. LONG    buff_size;                      /* buffer size req'd for scrn   */
  109. LONG    buff_location;                  /* scrn buffer pointer          */
  110. WORD    dodle_whndl;                    /* doodle window handle         */
  111. BOOLEAN dood_fill = FALSE;              /* fill or draw flag            */
  112. BOOLEAN first_fill = FALSE;             /* to set background color      */
  113. WORD    dodle_shade = SHADE1;           /* doodle current pen shade     */
  114. WORD    pen_ink = SHADE1;               /* current ink shade            */
  115. WORD    bkgr_color = SHADE0;            /* current background shade     */
  116. WORD    bkgr_next = SHADE0;             /* next background shade        */
  117. WORD    dodle_pen = 1;                  /* doodle current pen width     */
  118. WORD    dodle_height = 4;               /* doodle current char height   */
  119. WORD    char_fine;                      /* character height for fine    */
  120. WORD    char_medium;                    /* character height for medium  */
  121. WORD    char_broad;                     /* character height for broad   */
  122. WORD    monumber = 5;                   /* mouse form number            */
  123. LONG    mofaddr = 0x0L;                 /* mouse form address           */
  124. WORD    file_handle;                    /* file handle -> pict ld/sv    */
  125. BYTE    file_name[64] = "";             /* current pict file name       */
  126. BOOLEAN key_input;                      /* key inputting state          */
  127. WORD    key_xbeg;                       /* x position for line beginning*/
  128. WORD    key_ybeg;                       /* y position for line beginning*/
  129. WORD    key_xcurr;                      /* current x position           */
  130. WORD    key_ycurr;                      /* current y position           */
  131.                                         /* doodle window title          */
  132. BYTE    *wdw_title = "  Doodle2  Window ";
  133. /*      Mouse Data Structures   */
  134. WORD    erase_broad[37] =               /* mouse form for broad eraser  */
  135. {
  136.         7, 7, 1, 0, 1,
  137.         0x0000, 0x0000, 0x0000, 0x0000, /* mask */
  138.         0x0000, 0x1ff0, 0x1ff0, 0x1ff0,
  139.         0x1ff0, 0x1ff0, 0x0000, 0x0000,
  140.         0x0000, 0x0000, 0x0000, 0x0000,
  141.         0x0000, 0x0000, 0x0000, 0x0000, /* data */
  142.         0x7ffc, 0x600c, 0x600c, 0x600c,
  143.         0x600c, 0x600c, 0x7ffc, 0x0000,
  144.         0x0000, 0x0000, 0x0000, 0x0000
  145. };
  146. WORD    erase_medium[37] =              /* mouse form for medium eraser */
  147. {
  148.         7, 7, 1, 0, 1,
  149.         0x0000, 0x0000, 0x0000, 0x0000, /* mask */
  150.         0x0000, 0x0000, 0x07c0, 0x07c0,
  151.         0x07c0, 0x0000, 0x0000, 0x0000,
  152.         0x0000, 0x0000, 0x0000, 0x0000,
  153.         0x0000, 0x0000, 0x0000, 0x0000, /* data */
  154.         0x0000, 0x1ff0, 0x1830, 0x1830,
  155.         0x1830, 0x1ff0, 0x0000, 0x0000,
  156.         0x0000, 0x0000, 0x0000, 0x0000
  157. };
  158. WORD    erase_fine[37] =                /* mouse form for fine eraser   */
  159. {
  160.         7, 7, 1, 0, 1,
  161.         0x0000, 0x0000, 0x0000, 0x0000, /* mask */
  162.         0x0000, 0x0000, 0x0000, 0x0100,
  163.         0x0000, 0x0000, 0x0000, 0x0000,
  164.         0x0000, 0x0000, 0x0000, 0x0000,
  165.         0x0000, 0x0000, 0x0000, 0x0000, /* data */
  166.         0x0000, 0x0000, 0x07c0, 0x06c0,
  167.         0x07c0, 0x0000, 0x0000, 0x0000,
  168.         0x0000, 0x0000, 0x0000, 0x0000
  169. };
  170. /****                       Local Procedures                         ****/
  171. /*      min                     */
  172. WORD    min(a, b)                       /* return min of two values */
  173. WORD            a, b;
  174. {
  175.         return( (a < b) ? a : b );
  176. }
  177. /*      max                     */
  178. WORD    max(a, b)                       /* return max of two values */
  179. WORD            a, b;
  180. {
  181.         return( (a > b) ? a : b );
  182. }
  183.  
  184.  
  185. /*------------------------------*/
  186. /*      string_addr             */
  187. /*------------------------------*/
  188. LONG
  189. string_addr(which)              /* returns a tedinfo LONG string addr   */
  190. WORD    which;
  191. {
  192.         LONG    where;
  193.  
  194.         rsrc_gaddr(R_STRING, which, &where);
  195.         return (where);
  196. } 
  197.  
  198.  
  199. /*------------------------------*/
  200. /*      rc_equal                */
  201. /*------------------------------*/
  202. WORD
  203. rc_equal(p1, p2)                /* tests for two rectangles equal       */
  204. GRECT           *p1, *p2;
  205. {
  206.         if ((p1->g_x != p2->g_x) ||
  207.             (p1->g_y != p2->g_y) ||
  208.             (p1->g_w != p2->g_w) ||
  209.             (p1->g_h != p2->g_h))
  210.                 return(FALSE);
  211.         return(TRUE);
  212. }
  213.  
  214.  
  215.  
  216. /*------------------------------*/
  217. /*      rc_copy                 */
  218. /*------------------------------*/
  219. VOID
  220. rc_copy(psbox, pdbox)           /* copy source to destination rectangle */
  221. GRECT   *psbox;
  222. GRECT   *pdbox;
  223. {
  224.         pdbox->g_x = psbox->g_x;
  225.         pdbox->g_y = psbox->g_y;
  226.         pdbox->g_w = psbox->g_w;
  227.         pdbox->g_h = psbox->g_h;
  228. }
  229.  
  230.  
  231. /*------------------------------*/
  232. /*      rc_intersect            */
  233. /*------------------------------*/
  234. WORD
  235. rc_intersect(p1, p2)            /* compute intersect of two rectangles  */
  236. GRECT           *p1, *p2;
  237. {
  238.         WORD            tx, ty, tw, th;
  239.  
  240.         tw = min(p2->g_x + p2->g_w, p1->g_x + p1->g_w);
  241.         th = min(p2->g_y + p2->g_h, p1->g_y + p1->g_h);
  242.         tx = max(p2->g_x, p1->g_x);
  243.         ty = max(p2->g_y, p1->g_y);
  244.         p2->g_x = tx;
  245.         p2->g_y = ty;
  246.         p2->g_w = tw - tx;
  247.         p2->g_h = th - ty;
  248.         return( (tw > tx) && (th > ty) );
  249. }
  250.  
  251.  
  252. /*------------------------------*/
  253. /*      inside                  */
  254. /*------------------------------*/
  255. UWORD
  256. inside(x, y, pt)                /* determine if x,y is in rectangle     */
  257. UWORD           x, y;
  258. GRECT           *pt;
  259. {
  260.         if ( (x >= pt->g_x) && (y >= pt->g_y) &&
  261.             (x < pt->g_x + pt->g_w) && (y < pt->g_y + pt->g_h) )
  262.                 return(TRUE);
  263.         else
  264.                 return(FALSE);
  265. } /* inside */
  266.  
  267.  
  268. /*------------------------------*/
  269. /*      grect_to_array          */
  270. /*------------------------------*/
  271. VOID
  272. grect_to_array(area, array)     /* convert x,y,w,h to upr lt x,y and    */
  273. GRECT   *area;                  /*                    lwr rt x,y        */
  274. WORD    *array;
  275. {
  276.         *array++ = area->g_x;
  277.         *array++ = area->g_y;
  278.         *array++ = area->g_x + area->g_w - 1;
  279.         *array = area->g_y + area->g_h - 1;
  280. }
  281.  
  282.  
  283. /*------------------------------*/
  284. /*      rast_op                 */
  285. /*------------------------------*/
  286. VOID
  287. rast_op(mode, s_area, s_mfdb, d_area, d_mfdb)   /* bit block level trns */
  288. WORD    mode;
  289. GRECT   *s_area, *d_area;
  290. MFDB    *s_mfdb, *d_mfdb;
  291. {
  292.         WORD    pxy[8];
  293.  
  294.         grect_to_array(s_area, pxy);
  295.         grect_to_array(d_area, &pxy[4]);
  296.         vro_cpyfm(vdi_handle, mode, pxy, s_mfdb, d_mfdb);
  297. }
  298.  
  299.  
  300. /*------------------------------*/
  301. /*      do_open                 */
  302. /*------------------------------*/
  303. VOID
  304. do_open(wh, org_x, org_y, x, y, w, h)   /* grow and open specified wdw  */
  305. WORD    wh;
  306. WORD    org_x, org_y;
  307. WORD    x, y, w, h;
  308. {
  309.         graf_growbox(org_x, org_y, 21, 21, x, y, w, h);
  310.         wind_open(wh, x, y, w, h);
  311. }
  312.  
  313.  
  314. /*------------------------------*/
  315. /*      do_close                */
  316. /*------------------------------*/
  317. VOID
  318. do_close(wh, org_x, org_y)      /* close and shrink specified window    */
  319. WORD    wh;
  320. WORD    org_x, org_y;
  321. {
  322.         WORD    x, y, w, h;
  323.  
  324.         wind_get(wh, WF_CURRXYWH, &x, &y, &w, &h);
  325.         wind_close(wh);
  326.         graf_shrinkbox(org_x, org_y, 21, 21, x, y, w, h);
  327. }
  328.  
  329.  
  330. /*------------------------------*/
  331. /*      hndl_dial               */
  332. /*------------------------------*/
  333. WORD
  334. hndl_dial(tree, def, x, y, w, h)        /* center, display and get input*/
  335. LONG    tree;                           /*   from specified dialogue box*/
  336. WORD    def;
  337. WORD    x, y, w, h;
  338. {
  339.         WORD    xdial, ydial, wdial, hdial;
  340.         WORD    exit_obj;
  341.  
  342.         form_center(tree, &xdial, &ydial, &wdial, &hdial);
  343.         form_dial(0, x, y, w, h, xdial, ydial, wdial, hdial);
  344.         form_dial(1, x, y, w, h, xdial, ydial, wdial, hdial);
  345.         objc_draw(tree, ROOT, MAX_DEPTH, xdial, ydial, wdial, hdial);
  346.         exit_obj = form_do(tree, def);
  347.         form_dial(2, x, y, w, h, xdial, ydial, wdial, hdial);
  348.         form_dial(3, x, y, w, h, xdial, ydial, wdial, hdial);
  349.         return (exit_obj);
  350. }
  351.  
  352.  
  353. /*------------------------------*/
  354. /*      set_clip                */
  355. /*------------------------------*/
  356. VOID
  357. set_clip(clip_flag, s_area)     /* set clip to specified area   */
  358. WORD    clip_flag;
  359. GRECT   *s_area;
  360. {
  361.         WORD    pxy[4];
  362.  
  363.         grect_to_array(s_area, pxy);
  364.         vs_clip(vdi_handle, clip_flag, pxy);
  365. }
  366.  
  367.  
  368. /*------------------------------*/
  369. /*      align_x                 */
  370. /*------------------------------*/
  371. WORD
  372. align_x(x)              /* forces word alignment for column position    */
  373. WORD    x;              /*   rounding to nearest word                   */
  374. {
  375.         /*      return((x & 0xfff0) + ((x & 0x000c) ? 0x0010 : 0));     IBM */
  376.         return(x);      /* ATARI        */      
  377. }       
  378.  
  379.  
  380. /*
  381.  
  382. Page*/
  383. /************************************************************************/
  384. /************************************************************************/
  385. /****                                                                ****/
  386. /****                       Work Area Management                     ****/
  387. /****                                                                ****/
  388. /************************************************************************/
  389. /************************************************************************/
  390.  
  391.  
  392. /*------------------------------*/
  393. /*      set_work                */
  394. /*------------------------------*/
  395. VOID
  396. set_work(slider_update)         /* update undo area, clamping to page   */
  397. BOOLEAN slider_update;          /*   edges, and updt sliders if req'd   */
  398. {
  399.         WORD    i;
  400.  
  401.         wind_get(dodle_whndl, WF_WORKXYWH,
  402.         &work_area.g_x, &work_area.g_y,
  403.         &work_area.g_w, &work_area.g_h);
  404.  
  405.         undo_area.g_w = work_area.g_w;
  406.         undo_area.g_h = work_area.g_h;
  407.         /**/                           /* clamp work area to page edges */
  408.         if ((i = undo_mfdb.fwp - (undo_area.g_x + undo_area.g_w)) < 0)
  409.                 undo_area.g_x += i;
  410.         if ((i = undo_mfdb.fh - (undo_area.g_y + undo_area.g_h)) < 0)
  411.                 undo_area.g_y += i;
  412.  
  413.         if (slider_update)
  414.         {
  415.                 wind_set(dodle_whndl, WF_HSLIDE, UMD(undo_area.g_x, 1000,
  416.                         undo_mfdb.fwp - undo_area.g_w), 0, 0, 0);
  417.                 wind_set(dodle_whndl, WF_VSLIDE, UMD(undo_area.g_y, 1000,
  418.                         undo_mfdb.fh - undo_area.g_h), 0, 0, 0);
  419.                 wind_set(dodle_whndl, WF_HSLSIZE,UMD(work_area.g_w, 1000,
  420.                         undo_mfdb.fwp), 0, 0, 0);
  421.                 wind_set(dodle_whndl, WF_VSLSIZE,UMD(work_area.g_h, 1000,
  422.                         undo_mfdb.fh), 0, 0, 0);
  423.         }
  424.  
  425.         undo_area.g_x = align_x(undo_area.g_x);
  426.         /* only use portion of work_area on scrn        */
  427.         rc_intersect(&scrn_area, &work_area);
  428.         undo_area.g_w = work_area.g_w;
  429.         undo_area.g_h = work_area.g_h;
  430. }
  431.  
  432.  
  433. /*------------------------------*/
  434. /*      save_work               */
  435. /*------------------------------*/
  436. VOID
  437. save_work()                     /* copy work_area to undo_area buffer   */
  438. {
  439.         GRECT   tmp_area;
  440.  
  441.         rc_copy(&work_area,&tmp_area);
  442.         rc_intersect(&scrn_area,&tmp_area);
  443.         graf_mouse(M_OFF, 0x0L);
  444.         rast_op(3, &tmp_area, &scrn_mfdb, &undo_area, &undo_mfdb);
  445.         graf_mouse(M_ON, 0x0L);
  446. }
  447.  
  448.  
  449. /*------------------------------*/
  450. /*      restore_work            */
  451. /*------------------------------*/
  452. VOID
  453. restore_work()                  /* restore work_area from undo_area     */
  454. {
  455.         GRECT   tmp_area;
  456.  
  457.         rc_copy(&work_area,&tmp_area);
  458.         rc_intersect(&scrn_area,&tmp_area);
  459.         graf_mouse(M_OFF, 0x0L);
  460.         rast_op(3, &undo_area, &undo_mfdb, &tmp_area, &scrn_mfdb);
  461.         graf_mouse(M_ON, 0x0L);
  462. }
  463.  
  464.  
  465. /*
  466.  
  467. Page*/
  468. /************************************************************************/
  469. /************************************************************************/
  470. /****                                                                ****/
  471. /****                       Object Tree Manipulation                 ****/
  472. /****                                                                ****/
  473. /************************************************************************/
  474. /************************************************************************/
  475.  
  476.  
  477. /*------------------------------*/
  478. /*      do_obj                  */
  479. /*------------------------------*/
  480. VOID
  481. do_obj(tree, which, bit)        /* set specified bit in object state    */
  482. LONG    tree;
  483. WORD    which, bit;
  484. {
  485.         WORD    state;
  486.  
  487.         state = LWGET(OB_STATE(which));
  488.         LWSET(OB_STATE(which), state | bit);
  489. }
  490.  
  491.  
  492. /*------------------------------*/
  493. /*      undo_obj                */
  494. /*------------------------------*/
  495. VOID
  496. undo_obj(tree, which, bit)      /* clear specified bit in object state  */
  497. LONG    tree;
  498. WORD    which, bit;
  499. {
  500.         WORD    state;
  501.  
  502.         state = LWGET(OB_STATE(which));
  503.         LWSET(OB_STATE(which), state & ~bit);
  504. }
  505.  
  506. /*------------------------------*/
  507. /*      sel_obj                 */
  508. /*------------------------------*/
  509. VOID
  510. sel_obj(tree, which)            /* turn on selected bit of spcfd object */
  511. LONG    tree;
  512. WORD    which;
  513. {
  514.         do_obj(tree, which, SELECTED);
  515. }
  516.  
  517.  
  518. /*------------------------------*/
  519. /*      desel_obj               */
  520. /*------------------------------*/
  521. VOID
  522. desel_obj(tree, which)          /* turn off selected bit of spcfd object*/
  523. LONG    tree;
  524. WORD    which;
  525. {
  526.         undo_obj(tree, which, SELECTED);
  527. }
  528.  
  529.  
  530. /*------------------------------*/
  531. /*      enab_menu               */
  532. /*------------------------------*/
  533. VOID
  534. enab_menu(which)                /* enable specified menu item   */
  535. WORD    which;
  536. {
  537.         undo_obj(gl_menu, which, DISABLED);
  538. }
  539.  
  540. /*------------------------------*/
  541. /*      objc_xywh               */
  542. /*------------------------------*/
  543. VOID
  544. objc_xywh(tree, obj, p)         /* get x,y,w,h for specified object     */
  545. LONG    tree;
  546. WORD    obj;
  547. GRECT   *p;
  548. {
  549.         objc_offset(tree, obj, &p->g_x, &p->g_y);
  550.         p->g_w = LWGET(OB_WIDTH(obj));
  551.         p->g_h = LWGET(OB_HEIGHT(obj));
  552. }
  553. /****                       File Path Name Functions                 ****/
  554. /*      dial_name   ****************************************            */
  555. WORD    dial_name ( name )              /* dialogue box input filename  */
  556. BYTE    *name;
  557. {                   
  558.        LONG    tree ;
  559.        LONG    ted_addr ;
  560.        BYTE    c ;
  561.        WORD    i, j;
  562.        GRECT   box;
  563.  
  564.  
  565.        objc_xywh(gl_menu, DOODFILE, &box);
  566.        rsrc_gaddr( R_TREE, DOODSVAD, &tree) ;
  567.        ted_addr = LLGET(OB_SPEC(DOODNAME));
  568.        LLSET( ted_addr, ADDR(name) ) ;
  569.        LWSET( TE_TXTLEN(ted_addr),8);
  570.        name[0] = '\0';
  571.        if(hndl_dial(tree,DOODNAME,box.g_x,box.g_y,box.g_w,box.g_h)==DOODSOK)
  572.        {
  573.                i =
  574.                    j =  0;
  575.                while (TRUE)
  576.                {
  577.                        c = name[i++];
  578.                        if (!c)
  579.                                break ;
  580.                        if ( (c != ' ') && (c != '_') )
  581.                                name[j++] = c ;
  582.                }
  583.                if ( *name )
  584.                        strcpy( &name[j], ".DOO" ) ;
  585.                desel_obj(tree, DOODSOK);
  586.                return ((WORD) *name);
  587.        }
  588.        else
  589.        {
  590.                desel_obj(tree, DOODSCNL);
  591.                return (FALSE);
  592.        }
  593. }
  594.  
  595.  
  596. /*------------------------------*/
  597. /*      get_path                */
  598. /*------------------------------*/
  599. VOID
  600. get_path(tmp_path, spec)        /* get directory path name      */
  601. BYTE    *tmp_path, *spec;
  602. {
  603.         WORD    cur_drv;
  604.  
  605.         cur_drv = Dgetdrv();
  606.         tmp_path[0] = cur_drv + 'A';
  607.         tmp_path[1] = ':';
  608.         tmp_path[2] = '\\';
  609.         Dgetpath(ADDR(&tmp_path[3]), cur_drv+1);
  610.         if (strlen(tmp_path) > 3)
  611.                 strcat(tmp_path, "\\");
  612.         else
  613.                 tmp_path[2] = '\0';
  614.         strcat(tmp_path, spec);
  615. }
  616.  
  617.  
  618. /*------------------------------*/
  619. /*      add_file_name           */
  620. /*------------------------------*/
  621. VOID
  622. add_file_name(dname, fname)     /* replace name at end of input file spec*/
  623. BYTE    *dname, *fname;
  624. {
  625.         BYTE    c;
  626.         WORD    ii;
  627.  
  628.  
  629.         ii = strlen(dname);
  630.         while (ii && (((c = dname[ii-1])  != '\\') && (c != ':')))
  631.                 ii--;
  632.         dname[ii] = '\0';
  633.         strcat(dname, fname);
  634. }
  635.  
  636.  
  637. /*------------------------------*/
  638. /*      get_file                */
  639. /*------------------------------*/
  640. WORD
  641. get_file(loop)                  /* use file selector to get input file  */
  642. BOOLEAN loop;
  643. {
  644.         WORD    fs_iexbutton;
  645.         BYTE    fs_iinsel[13];
  646.  
  647.         while (TRUE)
  648.         {
  649.                 get_path(file_name, "*.DOO");
  650.                 fs_iinsel[0] = '\0';
  651.  
  652.                 fsel_input(ADDR(file_name), ADDR(fs_iinsel), &fs_iexbutton);
  653.                 if (fs_iexbutton)
  654.                 {
  655.                         add_file_name(file_name, fs_iinsel);
  656.                         file_handle = Fopen(ADDR(file_name),2);
  657.                         dos_err = (file_handle < 0) ? -1 : 0;
  658.                         if (!loop || (loop && !dos_err))
  659.                                 return(1);
  660.                 }
  661.                 else
  662.                         return (0);
  663.         }
  664. } /* get_file */
  665.  
  666.  
  667. /*
  668.  
  669. Page*/
  670. /************************************************************************/
  671. /************************************************************************/
  672. /****                                                                ****/
  673. /****                       Soft Cursor Support                      ****/
  674. /****                                                                ****/
  675. /************************************************************************/
  676. /************************************************************************/
  677.  
  678.  
  679. /*------------------------------*/
  680. /*      cursor                  */
  681. /*------------------------------*/
  682. VOID
  683. cursor(color)                   /* turn cursor on,  color = pen_ink     */
  684. WORD    color;                  /*   or cursor off, color = bkgr_color  */
  685. {
  686.         WORD    pxy[4];
  687.  
  688.         pxy[0] = key_xcurr + 1;
  689.         pxy[1] = key_ycurr + gl_hspace;
  690.         pxy[2] = key_xcurr + 1;
  691.         pxy[3] = key_ycurr - gl_hbox;
  692.  
  693.         vsl_color(vdi_handle,color);
  694.         vswr_mode(vdi_handle,MD_REPLACE);
  695.         vsl_type (vdi_handle,IP_1PATT);
  696.         vsl_width (vdi_handle,PEN_FINE);
  697.         v_pline(vdi_handle, 2, pxy);
  698. }
  699.  
  700.  
  701. /*------------------------------*/
  702. /*      curs_on                 */
  703. /*------------------------------*/
  704. VOID
  705. curs_on()                       /* turn 'soft' cursor 'on'      */
  706. {
  707.         cursor(pen_ink);
  708. }
  709.  
  710. /*------------------------------*/
  711. /*      curs_off                */
  712. /*------------------------------*/
  713. VOID
  714. curs_off()                      /* turn 'soft' cursor 'off'     */
  715. {
  716.         cursor(bkgr_color);
  717. }
  718.  
  719.  
  720. /*
  721.  
  722. Page*/
  723. /************************************************************************/
  724. /************************************************************************/
  725. /****                                                                ****/
  726. /****                       Menu Handling                            ****/
  727. /****                                                                ****/
  728. /************************************************************************/
  729. /************************************************************************/
  730.  
  731.  
  732. /*------------------------------*/
  733. /*      hdl_menu                */
  734. /*------------------------------*/
  735. WORD
  736. hdl_menu(title, item)
  737. WORD    title, item;
  738. {
  739.         WORD    done;
  740.         WORD    me_creturn;
  741.  
  742.         graf_mouse(ARROW, 0x0L);
  743.         done = FALSE;
  744.         switch (title) {
  745.         case DOODDESK:
  746.                 if (item == DOODINFO)
  747.                         do_about();
  748.                 break;
  749.  
  750.         case DOODFILE:
  751.                 switch (item)
  752.                 {
  753.                 case DOODLOAD:
  754.                         do_load(TRUE);
  755.                         break;
  756.                 case DOODSAVE:
  757.                         do_sav();
  758.                         break;
  759.                 case DOODSVAS:
  760.                         do_savas();
  761.                         break;
  762.                 case DOODABAN:
  763.                         file_handle = Fopen(ADDR(file_name),2);
  764.                         do_load(FALSE);
  765.                         break;
  766.                 case DOODQUIT:
  767.                         done = TRUE;
  768.                         break;
  769.                 }
  770.  
  771.         case DOODOPTS:
  772.                 switch (item)
  773.                 {
  774.                 case DOODPENS:
  775.                         do_penselect();
  776.                         break;
  777.                 case DOODERAP:
  778.                         do_erase();
  779.                         first_fill = TRUE;
  780.                         break;
  781.                 }
  782.  
  783.         case DOODCOLR:
  784.                 switch (item)
  785.                 {
  786.                 case COLOR0:
  787.                         pen_ink = SHADE0;
  788.                         do_clnormal();
  789.                         me_creturn = menu_icheck (gl_menu, COLOR0, SELECTED);
  790.                         break;
  791.                 case COLOR1:
  792.                         pen_ink = SHADE1;
  793.                         do_clnormal();
  794.                         me_creturn = menu_icheck (gl_menu, COLOR1, SELECTED);
  795.                         break;
  796.                 case COLOR2:
  797.                         pen_ink = SHADE2;
  798.                         do_clnormal();
  799.                         me_creturn = menu_icheck (gl_menu, COLOR2, SELECTED);
  800.                         break;
  801.                 case COLOR3:
  802.                         pen_ink = SHADE3;
  803.                         do_clnormal();
  804.                         me_creturn = menu_icheck (gl_menu, COLOR3, SELECTED);
  805.                         break;
  806.                 case COLOR4:
  807.                         pen_ink = SHADE4;
  808.                         do_clnormal();
  809.                         me_creturn = menu_icheck (gl_menu, COLOR4, SELECTED);
  810.                         break;
  811.                 case COLOR5:
  812.                         pen_ink = SHADE5;
  813.                         do_clnormal();
  814.                         me_creturn = menu_icheck (gl_menu, COLOR5, SELECTED);
  815.                         break;
  816.                 case COLOR6:
  817.                         pen_ink = SHADE6;
  818.                         do_clnormal();
  819.                         me_creturn = menu_icheck (gl_menu, COLOR6, SELECTED);
  820.                         break;
  821.                 case COLOR7:
  822.                         pen_ink = SHADE7;
  823.                         do_clnormal();
  824.                         me_creturn = menu_icheck (gl_menu, COLOR7, SELECTED);
  825.                         break;
  826.                 case COLOR8:
  827.                         pen_ink = SHADE8;
  828.                         do_clnormal();
  829.                         me_creturn = menu_icheck (gl_menu, COLOR8, SELECTED);
  830.                         break;
  831.                 case COLOR9:
  832.                         pen_ink = SHADE9;
  833.                         do_clnormal();
  834.                         me_creturn = menu_icheck (gl_menu, COLOR9, SELECTED);
  835.                         break;
  836.                 case COLOR10:
  837.                         pen_ink = SHADE10;
  838.                         do_clnormal();
  839.                         me_creturn = menu_icheck (gl_menu, COLOR10, SELECTED);
  840.                         break;
  841.                 case COLOR11:
  842.                         pen_ink = SHADE11;
  843.                         do_clnormal();
  844.                         me_creturn = menu_icheck (gl_menu, COLOR11, SELECTED);
  845.                         break;
  846.                 case COLOR12:
  847.                         pen_ink = SHADE12;
  848.                         do_clnormal();
  849.                         me_creturn = menu_icheck (gl_menu, COLOR12, SELECTED);
  850.                         break;
  851.                 case COLOR13:
  852.                         pen_ink = SHADE13;
  853.                         do_clnormal();
  854.                         me_creturn = menu_icheck (gl_menu, COLOR13, SELECTED);
  855.                         break;
  856.                 case COLOR14:
  857.                         pen_ink = SHADE14;
  858.                         do_clnormal();
  859.                         me_creturn = menu_icheck (gl_menu, COLOR14, SELECTED);
  860.                         break;
  861.                 case COLOR15:
  862.                         pen_ink = SHADE15;
  863.                         do_clnormal();
  864.                         me_creturn = menu_icheck (gl_menu, COLOR15, SELECTED);
  865.                         break;
  866.                 }
  867.  
  868.                 dodle_shade = pen_ink;
  869.  
  870.         }
  871.         menu_tnormal(gl_menu,title,TRUE);
  872.         graf_mouse(monumber, mofaddr);
  873.         return (done);
  874. }
  875.  
  876.  
  877. /*------------------------------*/
  878. /*      do_clnormal             */
  879. /*------------------------------*/
  880. VOID
  881. do_clnormal()   /*      set all color checks to NORMAL in color menu    */
  882. {
  883.         WORD    me_creturn;
  884.  
  885.         me_creturn = menu_icheck(gl_menu, COLOR0, NORMAL);
  886.         me_creturn = menu_icheck(gl_menu, COLOR1, NORMAL);
  887.         me_creturn = menu_icheck(gl_menu, COLOR2, NORMAL);
  888.         me_creturn = menu_icheck(gl_menu, COLOR3, NORMAL);
  889.         me_creturn = menu_icheck(gl_menu, COLOR4, NORMAL);
  890.         me_creturn = menu_icheck(gl_menu, COLOR5, NORMAL);
  891.         me_creturn = menu_icheck(gl_menu, COLOR6, NORMAL);
  892.         me_creturn = menu_icheck(gl_menu, COLOR7, NORMAL);
  893.         me_creturn = menu_icheck(gl_menu, COLOR8, NORMAL);
  894.         me_creturn = menu_icheck(gl_menu, COLOR9, NORMAL);
  895.         me_creturn = menu_icheck(gl_menu, COLOR10, NORMAL);
  896.         me_creturn = menu_icheck(gl_menu, COLOR11, NORMAL);
  897.         me_creturn = menu_icheck(gl_menu, COLOR12, NORMAL);
  898.         me_creturn = menu_icheck(gl_menu, COLOR13, NORMAL);
  899.         me_creturn = menu_icheck(gl_menu, COLOR14, NORMAL);
  900.         me_creturn = menu_icheck(gl_menu, COLOR15, NORMAL);
  901. }
  902.  
  903. /*------------------------------*/
  904. /*      do_about                */
  905. /*------------------------------*/
  906. VOID
  907. do_about()                      /* display Doodle Info...       */
  908. {
  909.         LONG    tree;
  910.         GRECT   box;
  911.  
  912.         objc_xywh(gl_menu, DOODDESK, &box);
  913.         rsrc_gaddr(R_TREE, DOODINFD, &tree);
  914.         hndl_dial(tree, 0, box.g_x, box.g_y, box.g_w, box.g_h);
  915.         desel_obj(tree, DOODOK);
  916. }
  917.  
  918.  
  919. /*------------------------------*/
  920. /*      do_load                 */
  921. /*------------------------------*/
  922. VOID
  923. do_load(need_name)              /* load doodle picture file     */
  924. BOOLEAN need_name;
  925. {
  926.         if (!need_name || get_file(TRUE))
  927.         {
  928.                 if (!dos_err)
  929.                 {
  930.                         Fread(file_handle, buff_size,buff_location);
  931.                         Fclose(file_handle);
  932.                         enab_menu(DOODSAVE);
  933.                         enab_menu(DOODABAN);
  934.                         restore_work();
  935.                 }
  936.         }
  937. }
  938.  
  939.  
  940. /*------------------------------*/
  941. /*      do_sav                  */
  942. /*------------------------------*/
  943. VOID
  944. do_sav()                        /* save current named doodle picture    */
  945. {
  946.         if (*file_name)
  947.         {
  948.                 file_handle = Fopen(ADDR(file_name),2);
  949.                 dos_err = (file_handle < 0) ? 1 : 0;
  950.                 if (dos_err)
  951.                         file_handle = Fcreate(ADDR(file_name),0);
  952.                 else
  953.                 {
  954.                         if (form_alert(1, string_addr(DOODOVWR)) == 2)
  955.                                 return;
  956.                 }
  957.                 Fwrite(file_handle, buff_size, buff_location);
  958.                 enab_menu(DOODSAVE);
  959.                 enab_menu(DOODABAN);
  960.                 Fclose(file_handle);
  961.         }
  962. }
  963.  
  964.  
  965. /*------------------------------*/
  966. /*      do_sav_as               */
  967. /*------------------------------*/
  968. VOID
  969. do_savas()                      /* save doodle picture as named */
  970. {
  971.         BYTE    name[13];
  972.  
  973.         if (dial_name(&name[0]))
  974.         {
  975.                 add_file_name(file_name, name);
  976.                 do_sav();
  977.         }
  978. }
  979.  
  980.  
  981. /*------------------------------*/
  982. /*      do_penselect            */
  983. /*------------------------------*/
  984. VOID
  985. do_penselect()                  /* use dialogue box to input selection  */
  986. {                               /*   of specified pen/eraser            */
  987.         WORD    exit_obj;
  988.         LONG    tree;
  989.         GRECT   box;
  990.  
  991.         objc_xywh(gl_menu, DOODPENS, &box);
  992.         rsrc_gaddr(R_TREE, DOODPEND, &tree);
  993.         /**/                    /* first setup current selection state  */
  994.         if (dodle_pen == PEN_FINE)
  995.         {
  996.                 sel_obj(tree, DOODFINE);
  997.                 desel_obj(tree, DOODMED);
  998.                 desel_obj(tree, DOODBRD);
  999.         }
  1000.         else
  1001.                 if (dodle_pen == PEN_MEDIUM)
  1002.                 {
  1003.                         sel_obj(tree, DOODMED);
  1004.                         desel_obj(tree, DOODFINE);
  1005.                         desel_obj(tree, DOODBRD);
  1006.                 }
  1007.                 else
  1008.                 {
  1009.                         sel_obj(tree, DOODBRD);
  1010.                         desel_obj(tree, DOODFINE);
  1011.                         desel_obj(tree, DOODMED);
  1012.                 }
  1013.         if (dodle_shade == pen_ink && dood_fill == FALSE)
  1014.         {
  1015.                 sel_obj(tree, DOODPEN);
  1016.                 desel_obj(tree, DOODERSR);
  1017.                 desel_obj(tree, DOODFILL);
  1018.         }
  1019.         else if (dodle_shade == pen_ink && dood_fill == TRUE)
  1020.         {
  1021.                 desel_obj(tree, DOODPEN);
  1022.                 desel_obj(tree, DOODERSR);
  1023.                 sel_obj(tree, DOODFILL);
  1024.         }
  1025.         else
  1026.         {
  1027.                 desel_obj(tree, DOODPEN);
  1028.                 sel_obj(tree, DOODERSR);
  1029.                 desel_obj(tree, DOODFILL);
  1030.         }
  1031.  
  1032.         /* get dialogue box input       */
  1033.  
  1034.         exit_obj = hndl_dial(tree, 0, box.g_x, box.g_y, box.g_w, box.g_h);
  1035.         if (exit_obj == DOODPSOK)
  1036.         {
  1037.                 if (LWGET(OB_STATE(DOODFINE)) & SELECTED)
  1038.                 {
  1039.                         dodle_pen = PEN_FINE;
  1040.                         dodle_height = char_fine;
  1041.                 }
  1042.                 else
  1043.                         if (LWGET(OB_STATE(DOODMED)) & SELECTED)
  1044.                         {
  1045.                                 dodle_pen = PEN_MEDIUM;
  1046.                                 dodle_height = char_medium;
  1047.                         }
  1048.                         else
  1049.                         {
  1050.                                 dodle_pen = PEN_BROAD;
  1051.                                 dodle_height = char_broad;
  1052.                         }
  1053.                 if (LWGET(OB_STATE(DOODPEN)) & SELECTED)
  1054.                 {
  1055.                         dodle_shade = pen_ink;
  1056.                         monumber = 5;
  1057.                         mofaddr = 0x0L;
  1058.                         dood_fill = FALSE;
  1059.                 }
  1060.                 else if (LWGET(OB_STATE(DOODERSR)) & SELECTED)
  1061.                 {
  1062.                    dodle_shade = bkgr_color;
  1063.                    monumber = 255;
  1064.                    mofaddr=(dodle_pen==PEN_FINE) ? ADDR((BYTE *)erase_fine):
  1065.                    (dodle_pen == PEN_MEDIUM) ? ADDR((BYTE *)erase_medium) :
  1066.                    ADDR((BYTE *)erase_broad);
  1067.                    dood_fill = FALSE;
  1068.                 }
  1069.                 else
  1070.                 {
  1071.                         dodle_shade = pen_ink;
  1072.                         monumber = POINT_HAND;
  1073.                         mofaddr = 0x0L;
  1074.                         dood_fill = TRUE;
  1075.                 }
  1076.  
  1077.                 desel_obj(tree, DOODPSOK);
  1078.         }
  1079.         else
  1080.                 desel_obj(tree, DOODCNCL);
  1081. }
  1082.  
  1083.  
  1084. /*------------------------------*/
  1085. /*      do_erase                */
  1086. /*------------------------------*/
  1087. VOID
  1088. do_erase()                      /* clear the scrn and the undo buffer   */
  1089. {
  1090.         WORD    fo_aexbttn;
  1091.  
  1092.         fo_aexbttn = form_alert(0, string_addr(ERASEWRN));
  1093.  
  1094.         if (fo_aexbttn == 1)
  1095.         {
  1096.                 rast_op(0, &scrn_area, &scrn_mfdb, &scrn_area, &undo_mfdb);
  1097.                 restore_work();
  1098.         }
  1099. }
  1100. /*
  1101.  
  1102. Page*/
  1103. /************************************************************************/
  1104. /************************************************************************/
  1105. /****                                                                ****/
  1106. /****                       Keyboard Handling                        ****/
  1107. /****                                                                ****/
  1108. /************************************************************************/
  1109. /************************************************************************/
  1110.  
  1111.  
  1112. /*------------------------------*/
  1113. /*      hndl_keyboard           */
  1114. /*------------------------------*/
  1115. WORD
  1116. hndl_keyboard()
  1117. {
  1118.         WORD    i;
  1119.         BYTE    str[2];
  1120.  
  1121.         if ((str[0] = kreturn) == 0x03)
  1122.                 return(TRUE);
  1123.         graf_mouse(M_OFF, 0x0L);
  1124.         if (!key_input)
  1125.         {
  1126.                 vsl_color(vdi_handle,dodle_shade);
  1127.                 vswr_mode(vdi_handle,MD_TRANS);
  1128.                 vsl_type (vdi_handle,IP_1PATT);
  1129.                 vst_height(vdi_handle, dodle_height,
  1130.                 &gl_wchar,&gl_hchar,&gl_wbox,&gl_hbox);
  1131.                 gl_hspace = gl_hbox - gl_hchar;
  1132.                 set_clip(TRUE, &work_area);
  1133.                 graf_mkstate(&key_xbeg, &key_ybeg, &i, &i);
  1134.                 key_xcurr = ++key_xbeg;
  1135.                 key_ycurr = --key_ybeg;
  1136.         }
  1137.         else
  1138.  
  1139.         /*      curs_off();     remove from color version 6/30/85       */
  1140.  
  1141.         str[1] = '\0';
  1142.         if (str[0] == 0x1A)
  1143.         {
  1144.                 save_work();
  1145.                 graf_mouse(M_ON, 0x0L);
  1146.                 return(key_input = FALSE);
  1147.         }
  1148.         else
  1149.                 if (str[0] == 0x0D)
  1150.                 {
  1151.                         key_ycurr += gl_hbox + gl_hspace;
  1152.                         key_xcurr = key_xbeg;
  1153.                 }
  1154.                 else
  1155.                         if (str[0] == 0x08)
  1156.                         {
  1157.                                 if (key_input && (key_xcurr != key_xbeg))
  1158.                                 {
  1159.                                         for (i = 0; i < gl_wbox; i++)
  1160.                                         {
  1161.                                                 key_xcurr--;
  1162.                                         /*      curs_off();     */
  1163.                                         }
  1164.                                 }
  1165.                         }
  1166.                         else
  1167.                                 if ((str[0] >= ' ') && (str[0] <= 'z'))
  1168.                                 {
  1169.                                         str[1] = '\0';
  1170.                                         vswr_mode(vdi_handle, MD_TRANS);
  1171.                                         vst_color(vdi_handle, pen_ink);
  1172.                                         v_gtext(vdi_handle, key_xcurr,
  1173.                                         key_ycurr, str);
  1174.                                         key_xcurr += gl_wbox;
  1175.                                 }
  1176.         if (!key_input)
  1177.         {
  1178.                 key_input = TRUE;
  1179.         }
  1180.         /*      curs_on();      remove from color version 6/30/85  */
  1181.         graf_mouse(M_ON, 0x0L);
  1182.         return(FALSE);
  1183. }
  1184. /****                       Message Handling                         ****/
  1185. /*      hndl_msg      *****************************************//*MLOCAL*/
  1186. BOOLEAN hndl_msg()
  1187. {
  1188.         BOOLEAN done; 
  1189.         WORD    wdw_hndl;
  1190.  
  1191.         done = FALSE;
  1192.         wdw_hndl = gl_rmsg[3];
  1193.         switch( gl_rmsg[0] )
  1194.         {
  1195.         case MN_SELECTED:
  1196.                 done = hdl_menu(wdw_hndl, gl_rmsg[4]);
  1197.                 break;
  1198.  
  1199.         case WM_REDRAW:
  1200.                 do_redraw(wdw_hndl, (GRECT *) &gl_rmsg[4]);
  1201.                 break;
  1202.  
  1203.         case WM_TOPPED:
  1204.                 wind_set(wdw_hndl, WF_TOP, 0, 0, 0, 0);
  1205.                 break;
  1206.         case WM_CLOSED:
  1207.                 done = TRUE;
  1208.                 break;
  1209.         case WM_FULLED:
  1210.                 do_full(wdw_hndl);
  1211.                 break;
  1212.         case WM_ARROWED:
  1213.                 switch(gl_rmsg[4])
  1214.                 {
  1215.                 case WA_UPPAGE:
  1216.                         undo_area.g_y = max(undo_area.g_y - undo_area.g_h, 0);
  1217.                         break;
  1218.                 case WA_DNPAGE:
  1219.                         undo_area.g_y += undo_area.g_h;
  1220.                         break;
  1221.                 case WA_UPLINE:
  1222.                         undo_area.g_y = max(undo_area.g_y - YSCALE(16), 0);
  1223.                         break;
  1224.                 case WA_DNLINE:
  1225.                         undo_area.g_y += YSCALE(16);
  1226.                         break;
  1227.                 case WA_LFPAGE:
  1228.                         undo_area.g_x = max(undo_area.g_x-undo_area.g_w, 0);
  1229.                         break;
  1230.                 case WA_RTPAGE:
  1231.                         undo_area.g_x += undo_area.g_w;
  1232.                         break;
  1233.                 case WA_LFLINE:
  1234.                         undo_area.g_x = max(undo_area.g_x - 16, 0);
  1235.                         break;
  1236.                 case WA_RTLINE:
  1237.                         undo_area.g_x += 16;
  1238.                         break;
  1239.                 }
  1240.                 set_work(TRUE);
  1241.                 restore_work();
  1242.                 break;
  1243.         case WM_HSLID:
  1244.                 undo_area.g_x = align_x(UMD(undo_mfdb.fwp - undo_area.g_w,
  1245.                 gl_rmsg[4], 1000));
  1246.                 wind_set(dodle_whndl, WF_HSLIDE, UMD(undo_area.g_x, 1000,
  1247.                 undo_mfdb.fwp - undo_area.g_w), 0, 0, 0);
  1248.                 restore_work();
  1249.                 break;
  1250.         case WM_VSLID:
  1251.                 undo_area.g_y = UMD(undo_mfdb.fh - undo_area.g_h,
  1252.                 gl_rmsg[4],1000);
  1253.                 wind_set(dodle_whndl, WF_VSLIDE, UMD(undo_area.g_y, 1000,
  1254.                 undo_mfdb.fh - undo_area.g_h), 0, 0, 0);
  1255.                 restore_work();
  1256.                 break;
  1257.         case WM_SIZED:
  1258.                 wind_set(wdw_hndl, WF_CURRXYWH, align_x(gl_rmsg[4]) - 1,
  1259.                 gl_rmsg[5], gl_rmsg[6], gl_rmsg[7]);
  1260.                 set_work(TRUE);
  1261.                 break;
  1262.         case WM_MOVED:
  1263.                 gl_rmsg[4] = align_x(gl_rmsg[4]);
  1264.                 wind_set(wdw_hndl, WF_CURRXYWH, align_x(gl_rmsg[4]) - 1,
  1265.                 gl_rmsg[5], gl_rmsg[6], gl_rmsg[7]);
  1266.                 set_work(FALSE);
  1267.                 break;
  1268.         } /* switch */
  1269.         return(done);
  1270. } /* hndl_msg */
  1271.  
  1272. /*------------------------------*/
  1273. /*      do_redraw               */
  1274. /*------------------------------*/
  1275. VOID
  1276. do_redraw(wh, area)             /* redraw specified area from undo bfr  */
  1277. WORD    wh;
  1278. GRECT   *area;
  1279. {
  1280.         GRECT   box;
  1281.         GRECT   dirty_source, dirty_dest;
  1282.  
  1283.         graf_mouse(M_OFF, 0x0L);
  1284.  
  1285.         wind_get(wh, WF_FIRSTXYWH, &box.g_x, &box.g_y, &box.g_w, &box.g_h);
  1286.         while ( box.g_w && box.g_h )
  1287.         {
  1288.                 if (rc_intersect(area, &box))
  1289.                 {
  1290.                         if (wh == dodle_whndl)
  1291.                         {
  1292.                             rc_copy(&box, &dirty_dest);
  1293.                             if (rc_intersect(&work_area, &dirty_dest))
  1294.                             {
  1295.                                dirty_source.g_x = (dirty_dest.g_x
  1296.                                           - work_area.g_x)  + undo_area.g_x;
  1297.                                dirty_source.g_y = (dirty_dest.g_y
  1298.                                           - work_area.g_y)  + undo_area.g_y;
  1299.                                dirty_source.g_w = dirty_dest.g_w;
  1300.                                dirty_source.g_h = dirty_dest.g_h;
  1301.                                rast_op(3, &dirty_source, &undo_mfdb,
  1302.                                     &dirty_dest, &scrn_mfdb);
  1303.                                 }
  1304.                         }
  1305.                 }
  1306.             wind_get(wh, WF_NEXTXYWH, &box.g_x, &box.g_y, &box.g_w, &box.g_h);
  1307.         }
  1308.         graf_mouse(M_ON, 0x0L);
  1309. }
  1310.  
  1311. /*------------------------------*/
  1312. /*      do_full                 */
  1313. /*------------------------------*/
  1314. VOID
  1315. do_full(wh)     /* depending on current window state, either make window*/
  1316. WORD    wh;     /*   full size -or- return to previous shrunken size    */
  1317. {
  1318.         GRECT   prev;
  1319.         GRECT   curr;
  1320.         GRECT   full;
  1321.  
  1322.         graf_mouse(M_OFF,0x0L);
  1323.         wind_get(wh, WF_CURRXYWH, &curr.g_x, &curr.g_y, &curr.g_w, &curr.g_h);
  1324.         wind_get(wh, WF_PREVXYWH, &prev.g_x, &prev.g_y, &prev.g_w, &prev.g_h);
  1325.         wind_get(wh, WF_FULLXYWH, &full.g_x, &full.g_y, &full.g_w, &full.g_h);
  1326.         if ( rc_equal(&curr, &full) )
  1327.         {                                       /* is full now so change*/
  1328.            /**/                                    /*   to previous     */
  1329.            graf_shrinkbox(prev.g_x, prev.g_y, prev.g_w, prev.g_h,
  1330.                         full.g_x, full.g_y, full.g_w, full.g_h);
  1331.            wind_set(wh,WF_CURRXYWH,prev.g_x,prev.g_y,prev.g_w,prev.g_h);
  1332.            rc_copy(&save_area, &undo_area);
  1333.            set_work(TRUE);
  1334.            if ((prev.g_x == full.g_x) && (prev.g_y == full.g_y))
  1335.                         do_redraw(wh, &work_area);
  1336.         }
  1337.         else
  1338.         {                                       /* is not full so make  */
  1339.            /**/                                    /*   it full         */
  1340.            rc_copy(&undo_area, &save_area);
  1341.            graf_growbox(curr.g_x, curr.g_y, curr.g_w, curr.g_h,
  1342.                         full.g_x, full.g_y, full.g_w, full.g_h);
  1343.            wind_set(wh, WF_CURRXYWH, full.g_x, full.g_y, full.g_w, full.g_h);
  1344.            set_work(TRUE);
  1345.         }
  1346.         graf_mouse(M_ON,0x0L);
  1347. }
  1348. /****                       Mouse Handling                           ****/
  1349. /*      hdl_mouse               */
  1350. WORD    hdl_mouse()
  1351. {
  1352.         BOOLEAN done;
  1353.  
  1354.         if (m_out)
  1355.                 graf_mouse(ARROW, 0x0L);
  1356.         else
  1357.                 graf_mouse(monumber, mofaddr);
  1358.  
  1359.         m_out = !m_out;
  1360.         done = FALSE;
  1361.         return(done);
  1362. }
  1363. /****                       Button Handling                          ****/
  1364. /*      hndl_button             */
  1365. WORD    hndl_button()
  1366. {
  1367.         WORD    done;
  1368.  
  1369.         done = FALSE;
  1370.         if (inside(mousex, mousey, &work_area))
  1371.         {
  1372.                 if (dood_fill == TRUE)
  1373.                         do_fill(mousex, mousey);
  1374.                 else
  1375.                         draw_pencil(mousex, mousey);
  1376.         }
  1377.         return(done);
  1378. }
  1379.  
  1380.  
  1381. /*------------------------------*/
  1382. /*      draw_pencil             */
  1383. /*------------------------------*/
  1384. WORD
  1385. draw_pencil(x, y)
  1386. UWORD   x, y;
  1387. {
  1388.         UWORD   pxy[4];
  1389.         WORD    done;
  1390.         UWORD   mflags;
  1391.         UWORD   locount, hicount;
  1392.         UWORD   ev_which, bbutton, kstate, kreturn, breturn;
  1393.  
  1394.         set_clip(TRUE, &work_area);
  1395.         pxy[0] = x;
  1396.         pxy[1] = y;
  1397.  
  1398.         vsl_color(vdi_handle,dodle_shade);
  1399.         vswr_mode(vdi_handle,MD_REPLACE);
  1400.         vsl_type (vdi_handle,IP_1PATT);
  1401.  
  1402.         if (dodle_shade == pen_ink)
  1403.         {
  1404.                 vsl_width (vdi_handle,dodle_pen);
  1405.                 vsl_ends(vdi_handle, 2, 2);
  1406.                 hicount = 0;
  1407.                 locount = 125;
  1408.                 mflags = MU_BUTTON | MU_M1 | MU_TIMER;
  1409.                 graf_mouse(M_OFF, 0x0L);
  1410.         }
  1411.         else
  1412.         {
  1413.                 vsf_interior(vdi_handle, 1);
  1414.                 vsf_color(vdi_handle, bkgr_color);
  1415.                 mflags = MU_BUTTON | MU_M1;
  1416.         }
  1417.  
  1418.         done = FALSE;
  1419.         while (!done)
  1420.         {
  1421.                 ev_which = evnt_multi(mflags,
  1422.                 0x01, 0x01, 0x00, 
  1423.                 1, pxy[0], pxy[1], 1, 1,
  1424.                 0, 0, 0, 0, 0,
  1425.                 ad_rmsg, locount, hicount,
  1426.                 &pxy[2], &pxy[3], &bbutton, &kstate,
  1427.                 &kreturn, &breturn);
  1428.  
  1429.                 if (ev_which & MU_BUTTON)
  1430.                 {
  1431.                         if (!(mflags & MU_TIMER))
  1432.                                 graf_mouse(M_OFF, 0x0L);
  1433.                         if (dodle_shade == pen_ink)
  1434.                                 v_pline(vdi_handle, 2, (WORD *) pxy);
  1435.                         else
  1436.                                 eraser((WORD) pxy[2], (WORD) pxy[3]);
  1437.                         graf_mouse(M_ON, 0x0L);
  1438.                         done = TRUE;
  1439.                 }
  1440.                 else
  1441.                         if (ev_which & MU_TIMER)
  1442.                         {
  1443.                                 graf_mouse(M_ON, 0x0L);
  1444.                                 mflags = MU_BUTTON | MU_M1;
  1445.                         }
  1446.                         else
  1447.                         {
  1448.                                 if (!(mflags & MU_TIMER))
  1449.                                         graf_mouse(M_OFF, 0x0L);
  1450.                                 if (dodle_shade == pen_ink)
  1451.                                 {
  1452.                                         v_pline(vdi_handle, 2, (WORD *) pxy);
  1453.                                         mflags = MU_BUTTON | MU_M1 | MU_TIMER;
  1454.                                 }
  1455.                                 else
  1456.                                 {
  1457.                                         eraser((WORD) pxy[2], (WORD) pxy[3]);
  1458.                                         graf_mouse(M_ON,0x0L);
  1459.                                 }
  1460.                                 pxy[0] = pxy[2];
  1461.                                 pxy[1] = pxy[3];
  1462.                         }
  1463.         } /* while */
  1464.  
  1465.         set_clip(FALSE, &work_area);
  1466.         save_work();
  1467. }
  1468.  
  1469.  
  1470. /*------------------------------*/
  1471. /*      eraser                  */
  1472. /*------------------------------*/
  1473. VOID
  1474. eraser(x, y)                    /* erase rectangle of eraser size at x,y */
  1475. WORD    x, y;
  1476. {
  1477.         WORD    erase_xy[4];
  1478.  
  1479.         if (dodle_pen == PEN_FINE)
  1480.         {
  1481.                 erase_xy[0] = x - 2;
  1482.                 erase_xy[1] = y - 1;
  1483.                 erase_xy[2] = x + 2;
  1484.                 erase_xy[3] = y + 1;
  1485.         }
  1486.         else
  1487.                 if (dodle_pen == PEN_MEDIUM)
  1488.                 {
  1489.                         erase_xy[0] = x - 4;
  1490.                         erase_xy[1] = y - 2;
  1491.                         erase_xy[2] = x + 4;
  1492.                         erase_xy[3] = y + 2;
  1493.                 }
  1494.                 else
  1495.                 {
  1496.                         erase_xy[0] = x - 6;
  1497.                         erase_xy[1] = y - 3;
  1498.                         erase_xy[2] = x + 6;
  1499.                         erase_xy[3] = y + 3;
  1500.                 }
  1501.         vr_recfl(vdi_handle, erase_xy);
  1502. }
  1503.  
  1504. /*----------------------------------------------*/
  1505. /*      do_fill         HK 6/30/85              */
  1506. /*----------------------------------------------*/
  1507. WORD
  1508. do_fill(x, y)
  1509. WORD x, y;
  1510. {
  1511.         WORD    index;
  1512.  
  1513.         vsf_interior(vdi_handle, IP_1PATT);
  1514.         vsf_color(vdi_handle, pen_ink);
  1515.         index = -1;     /* for complete fill */
  1516.  
  1517.         graf_mouse(M_OFF, 0x0L);
  1518.         v_contourfill(vdi_handle, x, y, index);
  1519.         save_work();
  1520.         graf_mouse(M_ON, 0x0L);
  1521.         
  1522.         if (first_fill == TRUE)
  1523.         {
  1524.                 bkgr_color = pen_ink;
  1525.                 first_fill = FALSE;
  1526.         }
  1527. }
  1528. /****                       Doodle Event Handler                     ****/
  1529. /*      dodle         ****************************************          */
  1530. VOID    dodle()
  1531. {
  1532.         BOOLEAN done;
  1533.  
  1534.         key_input = FALSE;
  1535.         done = FALSE;
  1536.         while( !done )          /* loop handling user input until done  */
  1537.         {
  1538.                 ev_which = evnt_multi(MU_BUTTON | MU_MESAG | MU_M1 | MU_KEYBD,
  1539.                 0x02, 0x01, 0x01, 
  1540.                 m_out,
  1541.                 (UWORD) work_area.g_x, (UWORD) work_area.g_y,
  1542.                 (UWORD) work_area.g_w, (UWORD) work_area.g_h,
  1543.                 0, 0, 0, 0, 0,
  1544.                 ad_rmsg, 0, 0, 
  1545.                 &mousex, &mousey, &bstate, &kstate,
  1546.                 &kreturn, &bclicks);
  1547.  
  1548.                 wind_update(BEG_UPDATE);
  1549.  
  1550.                 if (!(ev_which & MU_KEYBD))
  1551.                 {
  1552.                         if (key_input)
  1553.                         {
  1554. /*                              curs_off();     */
  1555.                                 key_input = FALSE;
  1556.                                 save_work();
  1557.                         }
  1558.                 }
  1559.  
  1560.                 if (ev_which & MU_BUTTON)
  1561.                         done = hndl_button();
  1562.  
  1563.                 if (ev_which & MU_M1)
  1564.                         done = hdl_mouse();
  1565.  
  1566.                 if (ev_which & MU_MESAG)
  1567.                         done = hndl_msg();
  1568.  
  1569.                 if (ev_which & MU_KEYBD)
  1570.                         done = hndl_keyboard();
  1571.  
  1572.                 wind_update(END_UPDATE);
  1573.         }
  1574. }
  1575. /*
  1576.  
  1577. Page*/
  1578. /************************************************************************/
  1579. /************************************************************************/
  1580. /****                                                                ****/
  1581. /****                       Termination                              ****/
  1582. /****                                                                ****/
  1583. /************************************************************************/
  1584. /************************************************************************/
  1585.  
  1586.  
  1587. /*------------------------------*/
  1588. /*      dodle_term              */
  1589. /*------------------------------*/
  1590. dodle_term(term_type)
  1591. WORD    term_type;
  1592. {
  1593.         switch (term_type)      /* NOTE: all cases fall through         */
  1594.         {
  1595.                 case (0 /* normal termination */):
  1596.                         do_close(dodle_whndl, gl_wfull/2, gl_hfull/2);
  1597.                         wind_delete(dodle_whndl);
  1598.                 case (3):
  1599.                         menu_bar(0x0L, FALSE);
  1600.                         Mfree(undo_mfdb.mp);
  1601.                 case (2):
  1602.                         v_clsvwk( vdi_handle );
  1603.                 case (1):
  1604.                         appl_exit();
  1605.                 case (4):
  1606.                         break;
  1607.         }
  1608. }
  1609. /****                       Initialization                           ****/
  1610. /*      dodle_init              */
  1611. WORD    dodle_init()
  1612. {
  1613.         WORD    work_in[11];
  1614.         WORD    i;
  1615.         WORD    me_creturn;
  1616.         gl_apid = appl_init();                  /* initialize libraries */
  1617.         if (gl_apid == -1)
  1618.                 return(4);
  1619.         wind_update(BEG_UPDATE);
  1620.         graf_mouse(HOURGLASS, 0x0L);
  1621.         if (!rsrc_load( ADDR("DOODLE2.RSC") ))
  1622.         {
  1623.                graf_mouse(ARROW, 0x0L);
  1624.                form_alert(1,
  1625.                ADDR("[3][Fatal Error !|DOODLE2.RSC|File Not Found][ Abort ]"));
  1626.                return(1);
  1627.         }
  1628.         /* open virtual workstation */
  1629.         /* allocate undo buffer */
  1630.         for (i=0; i<10; i++)
  1631.         {
  1632.                 work_in[i]=1;
  1633.         }
  1634.         work_in[10]=2;
  1635.  
  1636.         gem_handle = graf_handle(&gl_wchar,&gl_hchar,&gl_wbox,&gl_hbox);
  1637.         vdi_handle = gem_handle;
  1638.         v_opnvwk(work_in,&vdi_handle,work_out);
  1639.  
  1640.         if (vdi_handle == 0)
  1641.                 return(1);
  1642.  
  1643.         scrn_width = work_out[0] + 1;
  1644.         scrn_height = work_out[1] + 1;
  1645.         scrn_xsize = work_out[3];
  1646.         scrn_ysize = work_out[4];
  1647.  
  1648.         char_fine = work_out[46];
  1649.         char_medium = work_out[48];
  1650.         char_broad = char_medium * 2;
  1651.  
  1652.         vq_extnd(vdi_handle, 1, work_out);
  1653.         scrn_planes = work_out[4];
  1654.  
  1655.         undo_mfdb.fwp = scrn_width;
  1656.         undo_mfdb.fww = undo_mfdb.fwp>>4;
  1657.         undo_mfdb.fh = scrn_height;
  1658.         undo_mfdb.np = scrn_planes;
  1659.         undo_mfdb.ff = 0;
  1660.  
  1661.         buff_size = (LONG)(undo_mfdb.fwp>>3) *
  1662.             (LONG)undo_mfdb.fh *
  1663.             (LONG)undo_mfdb.np;
  1664.         buff_location =
  1665.             undo_mfdb.mp  = Malloc(buff_size);
  1666.         if (undo_mfdb.mp == 0)
  1667.                 return(2);
  1668.         scrn_area.g_x = 0;
  1669.         scrn_area.g_y = 0;
  1670.         scrn_area.g_w = scrn_width;
  1671.         scrn_area.g_h = scrn_height;
  1672.         scrn_mfdb.mp = 0x0L;
  1673.  
  1674.         rc_copy(&scrn_area, &undo_area);
  1675.         rast_op(0, &undo_area, &scrn_mfdb, &undo_area, &undo_mfdb);
  1676.  
  1677.         ad_rmsg = ADDR((BYTE *) &gl_rmsg[0]);
  1678.  
  1679.         wind_get(DESK, WF_WORKXYWH,&gl_xfull,&gl_yfull,&gl_wfull,&gl_hfull);
  1680.  
  1681.         /* initialize menu      */
  1682.         rsrc_gaddr(R_TREE, DOODMENU, &gl_menu);
  1683.         do_clnormal();
  1684.         me_creturn = menu_icheck (gl_menu, COLOR1, SELECTED);
  1685.  
  1686.         /* show menu            */
  1687.         menu_bar(gl_menu, TRUE);        
  1688.  
  1689.         dodle_whndl = wind_create(0x0fef, gl_xfull - 1, gl_yfull,
  1690.         gl_wfull, gl_hfull);
  1691.         if (dodle_whndl == -1)
  1692.         {
  1693.                 form_alert(1, string_addr(DOODNWDW));
  1694.                 return(3);
  1695.         }
  1696.  
  1697.         graf_mouse(HOURGLASS, 0x0L);
  1698.         wind_set(dodle_whndl, WF_NAME,
  1699.         " Dr. Doodle Window ", 0, 0);
  1700.         gl_xfull = align_x(gl_xfull);
  1701.         do_open(dodle_whndl, gl_wfull/2, gl_hfull/2, align_x(gl_xfull),
  1702.                 gl_yfull, gl_wfull, gl_hfull);
  1703.         wind_get(dodle_whndl, WF_WORKXYWH,
  1704.         &work_area.g_x, &work_area.g_y,
  1705.         &work_area.g_w, &work_area.g_h);
  1706.  
  1707.         set_work(TRUE);
  1708.         rc_copy (&undo_area, &save_area);
  1709.  
  1710.         graf_mouse(ARROW,0x0L);
  1711.         wind_update(END_UPDATE);
  1712.         return(0);
  1713. }
  1714. /****                       Main Program                             ****/
  1715. /*      main()                  */
  1716. WORD    main()
  1717. {
  1718.         WORD    term_type;
  1719.  
  1720.         if (!(term_type = dodle_init()))
  1721.                 dodle();
  1722.         dodle_term(term_type);
  1723. }
  1724.  
  1725. /*  FUNCTION     *********************************************************/
  1726. /* UMUL_DIV() I don't know who needs this in capitals letters but it won't
  1727.     UMD.......for easier typing.........     \  link without it otherwise*/
  1728. int UMD(m1, m2, d1)
  1729. unsigned int m1;
  1730. unsigned int m2;
  1731. unsigned int d1;
  1732. {
  1733.         unsigned int x;
  1734.         x = m2;
  1735.         x = x << 1;
  1736.         x *= m1;
  1737.         x /= d1;
  1738.         x += 1;
  1739.         x = x >> 1;
  1740.         return(x);
  1741. }
  1742.